package org.wu.framework.lazy.orm.database.lambda.stream.condition;

import org.wu.framework.lazy.orm.database.lambda.stream.condition.part.SqlPart;
import org.wu.framework.lazy.orm.database.lambda.stream.condition.select.AbstractSelectBasicComparison;

/**
 * @author : Jia wei Wu
 * @version 1.0
 * describe :
 * @date : 2021/8/23 8:36 下午
 */
public class StringBasicComparison<T> extends AbstractSelectBasicComparison<T, String, Object> {

    /**
     * @return describe 获取条件集合
     * @author Jia wei Wu
     * @date 2021/8/21 7:57 下午
     **/
    @Override
    public SqlPart getSqlPart() {
        return sqlPart;
    }

    /**
     * 忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> eqIgnoreEmpty(String row, Object var) {
        super.eqIgnoreEmpty(row, var);
        return this;
    }

    /**
     * 大于比较忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> gtIgnoreEmpty(String row, Object var) {
        super.gtIgnoreEmpty(row, var);
        return this;
    }

    /**
     * 小于比较忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> ltIgnoreEmpty(String row, Object var) {
        super.ltIgnoreEmpty(row, var);
        return this;
    }

    /**
     * like比较忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> likeIgnoreEmpty(String row, Object var) {
        super.likeIgnoreEmpty(row, var);
        return this;
    }

    /**
     * @param row 数据库列表达式
     * @param var 列匹配数据
     * @return describe like 左边条件。name like "zhang%"
     * @author Jia wei Wu
     * @date 2021/7/16 9:45 下午
     **/
    @Override
    public AbstractBasicComparison<T, String, Object> lLike(String row, Object var) {
        super.lLike(row, var);
        return this;
    }

    /**
     * like比较忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public AbstractBasicComparison<T, String, Object> gLikeIgnoreEmpty(String row, Object var) {
        super.gLikeIgnoreEmpty(row, var);
        return this;
    }

    /**
     * like比较忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public AbstractBasicComparison<T, String, Object> lLikeIgnoreEmpty(String row, Object var) {
        super.lLikeIgnoreEmpty(row, var);
        return this;
    }

    /**
     * @param row 数据库列表达式
     * @param var 列匹配数据
     * @return describe like 右边条件。name like "%zhang"
     * @author Jia wei Wu
     * @date 2021/7/16 9:45 下午
     **/
    @Override
    public AbstractBasicComparison<T, String, Object> gLike(String row, Object var) {
        super.gLike(row, var);
        return this;
    }

    /**
     * no like 比较忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> notLikeIgnoreEmpty(String row, Object var) {
        super.notLikeIgnoreEmpty(row, var);
        return this;
    }

    /**
     * in 查询 忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> inIgnoreEmpty(String row, Object var) {
        super.inIgnoreEmpty(row, var);
        return this;
    }

    /**
     * not in 查询 忽略空数据
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> notInIgnoreEmpty(String row, Object var) {
        super.notInIgnoreEmpty(row, var);
        return this;
    }

    @Override
    public StringBasicComparison<T> apply(String applySql, Object... values) {
        super.apply(applySql, values);
        return this;
    }

    /**
     * @param row 数据库列表达式
     * @param var 列匹配数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> eq(String row, Object var) {
        super.eq(row, var);
        return this;
    }

    /**
     * 或查询
     *
     * @param row 行
     * @param var 行数据
     * @return C 返回数据
     */
    @Override
    public StringBasicComparison<T> or(String row, Object var) {
        super.or(row, var);
        return this;
    }

    /**
     * @param row 数据库列表达式
     * @param var 列匹配数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> ne(String row, Object var) {
        super.ne(row, var);
        return this;
    }

    /**
     * 大于查询
     *
     * @param row 数据库列表达式
     * @param var 列匹配数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> gt(String row, Object var) {
        super.gt(row, var);
        return this;
    }

    /**
     * @param row 数据库列表达式
     * @param var 列匹配数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> lt(String row, Object var) {
        super.lt(row, var);
        return this;
    }

    @Override
    public StringBasicComparison<T> like(String row, Object var) {
        super.like(row, var);
        return this;
    }

    /**
     * @param row 数据库列表达式
     * @param var 列匹配数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> notLike(String row, Object var) {
        super.notLike(row, var);
        return this;
    }

    /**
     * in 查询
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> in(String row, Object var) {
        super.in(row, var);
        return this;
    }

    /**
     * 将in查询替换为 or
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> inOr(String row, Object var) {
        super.inOr(row, var);
        return this;
    }

    /**
     * in 查询
     *
     * @param row 行
     * @param var 数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> notIn(String row, Object var) {
        super.notIn(row, var);
        return this;
    }

    /**
     * @param row      数据库列表达式
     * @param leftVar  列匹配数据
     * @param rightVar 列匹配数据
     * @return C
     */
    @Override
    public StringBasicComparison<T> between(String row, Object leftVar, Object rightVar) {
        super.between(row, leftVar, rightVar);
        return this;
    }

    /**
     * describe 降序
     *
     * @param rows 排序字段
     * @return C
     * @author Jia wei Wu
     * @date 2022/6/26 21:51
     **/
    @Override
    public StringBasicComparison<T> orderByDesc(String... rows) {
        super.orderByDesc(rows);
        return this;
    }

    /**
     * describe 升序
     *
     * @param rows 排序字段
     * @return C
     * @author Jia wei Wu
     * @date 2022/6/26 21:51
     **/
    @Override
    public StringBasicComparison<T> orderByAsc(String... rows) {
        super.orderByAsc(rows);
        return this;
    }

    @Override
    public StringBasicComparison<T> eqo(String row, Object var) {
        super.eqo(row, var);
        return this;
    }

    @Override
    public StringBasicComparison<T> neo(String row, Object var) {
        super.neo(row, var);
        return this;
    }

    /**
     * 忽略空数据
     *
     * @param row
     * @param var
     * @return
     */
    @Override
    public StringBasicComparison<T> eqoIgnoreEmpty(String row, Object var) {
        super.eqoIgnoreEmpty(row, var);
        return this;
    }

    @Override
    public StringBasicComparison<T> gto(String row, Object var) {
        super.gto(row, var);
        return this;
    }

    @Override
    public StringBasicComparison<T> lto(String row, Object var) {
        super.lto(row, var);
        return this;
    }

    @Override
    public StringBasicComparison<T> likeO(String row, Object var) {
        super.likeO(row, var);
        return this;
    }

    @Override
    public StringBasicComparison<T> notLikeO(String row, Object var) {
        super.notLikeO(row, var);
        return this;
    }

    /**
     * in 查询
     *
     * @param row 行
     * @param var 数据
     * @return
     */
    @Override
    public StringBasicComparison<T> ino(String row, Object var) {
        super.ino(row, var);
        return this;
    }

    /**
     * in 查询
     *
     * @param row 行
     * @param var 数据
     * @return
     */
    @Override
    public StringBasicComparison<T> notIno(String row, Object var) {
        super.notIno(row, var);
        return this;
    }

    /**
     * 忽略空数据
     * <p>
     * in 查询
     *
     * @param row 行
     * @param var 数据
     * @return
     */
    @Override
    public StringBasicComparison<T> inIgnoreEmptyO(String row, Object var) {
        super.inIgnoreEmptyO(row, var);
        return this;
    }

    @Override
    public StringBasicComparison<T> betweenO(String row, Object leftVar, Object rightVar) {
        super.betweenO(row, leftVar, rightVar);
        return this;
    }

}
